"""
__twostations_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Fri Jan  4 20:12:25 2013
_________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Station_S import *
from Male_S import *
from Female_S import *
from directLink_S import *
from graph_Station_S import *
from graph_Female_S import *
from graph_directLink_S import *
from graph_Male_S import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def twostations_MDL(self, rootNode, SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG SimpleDSLTransMM ---
    if( SimpleDSLTransMMRootNode ): 
        # author
        SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        SimpleDSLTransMMRootNode.description.setValue('\n')
        SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        SimpleDSLTransMMRootNode.name.setValue('TwoStations')
    # --- ASG attributes over ---


    self.obj30=Station_S(self)
    self.obj30.isGraphObjectVisual = True

    if(hasattr(self.obj30, '_setHierarchicalLink')):
      self.obj30._setHierarchicalLink(False)

    # name
    self.obj30.name.setValue('s1')

    self.obj30.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(560.0,220.0,self.obj30)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj30.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj30)
    self.globalAndLocalPostcondition(self.obj30, rootNode)
    self.obj30.postAction( rootNode.CREATE )

    self.obj31=Station_S(self)
    self.obj31.isGraphObjectVisual = True

    if(hasattr(self.obj31, '_setHierarchicalLink')):
      self.obj31._setHierarchicalLink(False)

    # name
    self.obj31.name.setValue('s2')

    self.obj31.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(840.0,220.0,self.obj31)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj31.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj31)
    self.globalAndLocalPostcondition(self.obj31, rootNode)
    self.obj31.postAction( rootNode.CREATE )

    self.obj32=Station_S(self)
    self.obj32.isGraphObjectVisual = True

    if(hasattr(self.obj32, '_setHierarchicalLink')):
      self.obj32._setHierarchicalLink(False)

    # name
    self.obj32.name.setValue('s3')

    self.obj32.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(1120.0,220.0,self.obj32)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj32.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj32)
    self.globalAndLocalPostcondition(self.obj32, rootNode)
    self.obj32.postAction( rootNode.CREATE )

    self.obj43=Male_S(self)
    self.obj43.isGraphObjectVisual = True

    if(hasattr(self.obj43, '_setHierarchicalLink')):
      self.obj43._setHierarchicalLink(False)

    # name
    self.obj43.name.setValue('m1')

    self.obj43.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(560.0,40.0,self.obj43)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj43.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj43)
    self.globalAndLocalPostcondition(self.obj43, rootNode)
    self.obj43.postAction( rootNode.CREATE )

    self.obj44=Male_S(self)
    self.obj44.isGraphObjectVisual = True

    if(hasattr(self.obj44, '_setHierarchicalLink')):
      self.obj44._setHierarchicalLink(False)

    # name
    self.obj44.name.setValue('m2')

    self.obj44.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(760.0,40.0,self.obj44)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj44.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj44)
    self.globalAndLocalPostcondition(self.obj44, rootNode)
    self.obj44.postAction( rootNode.CREATE )

    self.obj45=Male_S(self)
    self.obj45.isGraphObjectVisual = True

    if(hasattr(self.obj45, '_setHierarchicalLink')):
      self.obj45._setHierarchicalLink(False)

    # name
    self.obj45.name.setValue('m3')

    self.obj45.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(920.0,40.0,self.obj45)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj45.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj45)
    self.globalAndLocalPostcondition(self.obj45, rootNode)
    self.obj45.postAction( rootNode.CREATE )

    self.obj46=Male_S(self)
    self.obj46.isGraphObjectVisual = True

    if(hasattr(self.obj46, '_setHierarchicalLink')):
      self.obj46._setHierarchicalLink(False)

    # name
    self.obj46.name.setValue('m4')

    self.obj46.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(1120.0,40.0,self.obj46)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj46.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj46)
    self.globalAndLocalPostcondition(self.obj46, rootNode)
    self.obj46.postAction( rootNode.CREATE )

    self.obj33=Female_S(self)
    self.obj33.isGraphObjectVisual = True

    if(hasattr(self.obj33, '_setHierarchicalLink')):
      self.obj33._setHierarchicalLink(False)

    # name
    self.obj33.name.setValue('f1')

    self.obj33.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(480.0,420.0,self.obj33)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj33.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj33)
    self.globalAndLocalPostcondition(self.obj33, rootNode)
    self.obj33.postAction( rootNode.CREATE )

    self.obj34=Female_S(self)
    self.obj34.isGraphObjectVisual = True

    if(hasattr(self.obj34, '_setHierarchicalLink')):
      self.obj34._setHierarchicalLink(False)

    # name
    self.obj34.name.setValue('f2')

    self.obj34.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(640.0,420.0,self.obj34)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj34.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj34)
    self.globalAndLocalPostcondition(self.obj34, rootNode)
    self.obj34.postAction( rootNode.CREATE )

    self.obj35=Female_S(self)
    self.obj35.isGraphObjectVisual = True

    if(hasattr(self.obj35, '_setHierarchicalLink')):
      self.obj35._setHierarchicalLink(False)

    # name
    self.obj35.name.setValue('f3')

    self.obj35.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(840.0,420.0,self.obj35)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj35.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj35)
    self.globalAndLocalPostcondition(self.obj35, rootNode)
    self.obj35.postAction( rootNode.CREATE )

    self.obj36=Female_S(self)
    self.obj36.isGraphObjectVisual = True

    if(hasattr(self.obj36, '_setHierarchicalLink')):
      self.obj36._setHierarchicalLink(False)

    # name
    self.obj36.name.setValue('f4')

    self.obj36.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(1040.0,420.0,self.obj36)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj36.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj36)
    self.globalAndLocalPostcondition(self.obj36, rootNode)
    self.obj36.postAction( rootNode.CREATE )

    self.obj37=Female_S(self)
    self.obj37.isGraphObjectVisual = True

    if(hasattr(self.obj37, '_setHierarchicalLink')):
      self.obj37._setHierarchicalLink(False)

    # name
    self.obj37.name.setValue('f5')

    self.obj37.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(1200.0,420.0,self.obj37)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj37.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj37)
    self.globalAndLocalPostcondition(self.obj37, rootNode)
    self.obj37.postAction( rootNode.CREATE )

    self.obj38=directLink_S(self)
    self.obj38.isGraphObjectVisual = True

    if(hasattr(self.obj38, '_setHierarchicalLink')):
      self.obj38._setHierarchicalLink(False)

    self.obj38.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(581.0,361.0,self.obj38)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj38.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj38)
    self.globalAndLocalPostcondition(self.obj38, rootNode)
    self.obj38.postAction( rootNode.CREATE )

    self.obj39=directLink_S(self)
    self.obj39.isGraphObjectVisual = True

    if(hasattr(self.obj39, '_setHierarchicalLink')):
      self.obj39._setHierarchicalLink(False)

    self.obj39.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(661.0,361.0,self.obj39)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj39.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj39)
    self.globalAndLocalPostcondition(self.obj39, rootNode)
    self.obj39.postAction( rootNode.CREATE )

    self.obj40=directLink_S(self)
    self.obj40.isGraphObjectVisual = True

    if(hasattr(self.obj40, '_setHierarchicalLink')):
      self.obj40._setHierarchicalLink(False)

    self.obj40.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(901.0,361.0,self.obj40)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj40.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj40)
    self.globalAndLocalPostcondition(self.obj40, rootNode)
    self.obj40.postAction( rootNode.CREATE )

    self.obj41=directLink_S(self)
    self.obj41.isGraphObjectVisual = True

    if(hasattr(self.obj41, '_setHierarchicalLink')):
      self.obj41._setHierarchicalLink(False)

    self.obj41.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(1141.0,361.0,self.obj41)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj41.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj41)
    self.globalAndLocalPostcondition(self.obj41, rootNode)
    self.obj41.postAction( rootNode.CREATE )

    self.obj42=directLink_S(self)
    self.obj42.isGraphObjectVisual = True

    if(hasattr(self.obj42, '_setHierarchicalLink')):
      self.obj42._setHierarchicalLink(False)

    self.obj42.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(1221.0,361.0,self.obj42)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj42.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj42)
    self.globalAndLocalPostcondition(self.obj42, rootNode)
    self.obj42.postAction( rootNode.CREATE )

    self.obj55=directLink_S(self)
    self.obj55.isGraphObjectVisual = True

    if(hasattr(self.obj55, '_setHierarchicalLink')):
      self.obj55._setHierarchicalLink(False)

    self.obj55.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(621.0,171.0,self.obj55)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj55.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj55)
    self.globalAndLocalPostcondition(self.obj55, rootNode)
    self.obj55.postAction( rootNode.CREATE )

    self.obj56=directLink_S(self)
    self.obj56.isGraphObjectVisual = True

    if(hasattr(self.obj56, '_setHierarchicalLink')):
      self.obj56._setHierarchicalLink(False)

    self.obj56.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(861.0,171.0,self.obj56)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj56.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj56)
    self.globalAndLocalPostcondition(self.obj56, rootNode)
    self.obj56.postAction( rootNode.CREATE )

    self.obj57=directLink_S(self)
    self.obj57.isGraphObjectVisual = True

    if(hasattr(self.obj57, '_setHierarchicalLink')):
      self.obj57._setHierarchicalLink(False)

    self.obj57.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(941.0,171.0,self.obj57)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj57.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj57)
    self.globalAndLocalPostcondition(self.obj57, rootNode)
    self.obj57.postAction( rootNode.CREATE )

    self.obj58=directLink_S(self)
    self.obj58.isGraphObjectVisual = True

    if(hasattr(self.obj58, '_setHierarchicalLink')):
      self.obj58._setHierarchicalLink(False)

    self.obj58.graphClass_= graph_directLink_S
    if self.genGraphics:
       new_obj = graph_directLink_S(1181.0,171.0,self.obj58)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj58.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj58)
    self.globalAndLocalPostcondition(self.obj58, rootNode)
    self.obj58.postAction( rootNode.CREATE )

    # Connections for obj30 (graphObject_: Obj0) named s1
    self.drawConnections(
(self.obj30,self.obj38,[621.0, 261.0, 581.0, 361.0],"true", 2),
(self.obj30,self.obj39,[621.0, 261.0, 661.0, 361.0],"true", 2) )
    # Connections for obj31 (graphObject_: Obj1) named s2
    self.drawConnections(
(self.obj31,self.obj40,[901.0, 261.0, 901.0, 361.0],"true", 2) )
    # Connections for obj32 (graphObject_: Obj2) named s3
    self.drawConnections(
(self.obj32,self.obj41,[1181.0, 261.0, 1141.0, 361.0],"true", 2),
(self.obj32,self.obj42,[1181.0, 261.0, 1221.0, 361.0],"true", 2) )
    # Connections for obj43 (graphObject_: Obj13) named m1
    self.drawConnections(
(self.obj43,self.obj55,[621.0, 81.0, 621.0, 171.0],"true", 2) )
    # Connections for obj44 (graphObject_: Obj14) named m2
    self.drawConnections(
(self.obj44,self.obj56,[821.0, 81.0, 861.0, 171.0],"true", 2) )
    # Connections for obj45 (graphObject_: Obj15) named m3
    self.drawConnections(
(self.obj45,self.obj57,[981.0, 81.0, 941.0, 171.0],"true", 2) )
    # Connections for obj46 (graphObject_: Obj16) named m4
    self.drawConnections(
(self.obj46,self.obj58,[1181.0, 81.0, 1181.0, 171.0],"true", 2) )
    # Connections for obj33 (graphObject_: Obj3) named f1
    self.drawConnections(
 )
    # Connections for obj34 (graphObject_: Obj4) named f2
    self.drawConnections(
 )
    # Connections for obj35 (graphObject_: Obj5) named f3
    self.drawConnections(
 )
    # Connections for obj36 (graphObject_: Obj6) named f4
    self.drawConnections(
 )
    # Connections for obj37 (graphObject_: Obj7) named f5
    self.drawConnections(
 )
    # Connections for obj38 (graphObject_: Obj8) of type directLink_S
    self.drawConnections(
(self.obj38,self.obj33,[581.0, 361.0, 541.0, 461.0],"true", 2) )
    # Connections for obj39 (graphObject_: Obj9) of type directLink_S
    self.drawConnections(
(self.obj39,self.obj34,[661.0, 361.0, 701.0, 461.0],"true", 2) )
    # Connections for obj40 (graphObject_: Obj10) of type directLink_S
    self.drawConnections(
(self.obj40,self.obj35,[901.0, 361.0, 901.0, 461.0],"true", 2) )
    # Connections for obj41 (graphObject_: Obj11) of type directLink_S
    self.drawConnections(
(self.obj41,self.obj36,[1141.0, 361.0, 1101.0, 461.0],"true", 2) )
    # Connections for obj42 (graphObject_: Obj12) of type directLink_S
    self.drawConnections(
(self.obj42,self.obj37,[1221.0, 361.0, 1261.0, 461.0],"true", 2) )
    # Connections for obj55 (graphObject_: Obj17) of type directLink_S
    self.drawConnections(
(self.obj55,self.obj30,[621.0, 171.0, 621.0, 261.0],"true", 2) )
    # Connections for obj56 (graphObject_: Obj18) of type directLink_S
    self.drawConnections(
(self.obj56,self.obj31,[861.0, 171.0, 901.0, 261.0],"true", 2) )
    # Connections for obj57 (graphObject_: Obj19) of type directLink_S
    self.drawConnections(
(self.obj57,self.obj31,[941.0, 171.0, 901.0, 261.0],"true", 2) )
    # Connections for obj58 (graphObject_: Obj20) of type directLink_S
    self.drawConnections(
(self.obj58,self.obj32,[1181.0, 171.0, 1181.0, 261.0],"true", 2) )

newfunction = twostations_MDL

loadedMMName = 'SimpleDSLTransMM_META'

atom3version = '0.3'
